Color Basics
Volume 9
Number 11
Column Tab Getting Started
The Basics of Color Quickdraw 
Using a color grafport and multiple monitors
By Dave Mark, MacTech Magazine Regular Contributing Author
Note: Source code files accompanying article are located on MacTech CD-ROM orsource code disks.
Last month’s column introduced some of the basics of C++ and object
programming. This month, we’ll turn our attention back to C and the Macintosh
Toolbox. This month’s column introduces one of the most enjoyable parts of the Mac
Toolbox, Color QuickDraw. Along the way, we’ll learn how to use Gestalt(), the
Toolbox function that knows everything there is to know about the current state of
your Macintosh.
So far, about the only real experience we’ve had with color has been with a
program that displayed a color PICT in a window. Since any possible color work was
handled by the routine DrawPicture(), we won’t even count that as color experience.
This month’s program is called ColorMondrian, a colorized version of an early Mac
Primer program called Mondrian.
Mondrian created a window and drew a never-ending series of randomly
generated QuickDraw shapes in the window. All this was done in the plain old
black-and-white of QuickDraw version 1, the version of QuickDraw that shipped
with the original 128K Macintosh.
Ever since the introduction of the Macintosh II, all Macs have shipped with a
new version of QuickDraw known as Color QuickDraw, also known as 8-bit Color
QuickDraw. As the technology marched on, 24-bit and then 32-bit Color QuickDraw
made their way into the Toolbox. For now, we’ll concentrate on the features common
to all flavors of Color QuickDraw.
ColorMondrian starts by checking to see if Color QuickDraw is available on the
current Macintosh. If so, it looks at each of the displays connected to the Mac
(remember, your Mac can have multiple monitors hooked up at the same time!) to
determine which display is the deepest, that is, can display the largest number of
colors. For example, if you have an 8-bit monitor (256 simultaneous colors) and a
1-bit monitor (black and white only), ColorMondrian will identify the 8-bit
monitor as the deepest.
Next, ColorMondrian will open a color window on the specified monitor and
start drawing randomly sized QuickDraw shapes in randomly selected colors. If your
deepest monitor is gray-scale, don’t worry. Shades of gray count as colors too!
Let’s get started. As has been the case of late, we’ll get the program running
this month, then walk through the code next month.
Creating the ColorMondrian Resources
Start by creating a folder labeled ColorMondrian in your Development folder.
Next, launch ResEdit and create a new file called ColorMondrian.π.rsrc in the
ColorMondrian folder.
Create a new MBAR resource with a resource id of 128. Enter the MENU ids
128, 129, 130, and 131 as shown in Figure 1.
Figure 1. The MBAR resource.
Next, create four MENU resources. The first, having a resource id of 128, will
match the menu shown in Figure 2. It’s an menu with a single item, About
ColorMondrian....
Figure 2. The menu.
The second menu should match the one shown in Figure 3. The title is File with
a single item, Be sure to add the command-key equivalent, Q.
Figure 3. The File menu.
The third menu should match the one shown in Figure 4. It’s a standard Edit
menu with a single separator line and all the standard command-key equivalents.
Figure 4. The Edit menu.
The fourth menu consists of a title and no items. The title is Devices, as shown
in Figure 5.
Figure 5. The Devices menu.
Next you’ll create two ALRT resources along with their respective DITLs, one
for displaying error messages, and one to bring up when About ColorMondrian... is
selected from the menu. First the error ALRT. Create an ALRT resource with a
resource id of 128, using the sizing info in Figure 6.
Figure 6. Specifications for the error ALRT.
Double-click on the alert window to bring up a DITL editor. Create two items,
an OK button (Figure 7) and a static text item (Figure 8).
Figure 7. Specifications for the OK button.
Figure 8. Specification for the static text item.
Now create a second ALRT with a resource id of 129. using the sizing info in
Figure 9.
Figure 9. Specifications for the about ALRT.
Double-click on the alert window to bring up a DITL editor. Create two items,
an OK button (Figure 10) and a static text item (Figure 11).
Figure 10. Specifications for the OK button.
Figure 11. Specification for the static text item.
Creating the ColorMondrian Project
Quit ResEdit, being sure to Save your changes. Now launch THINK C and create a
new project named ColorMondrian.π in the ColorMondrian folder. Add the MacTraps
and ANSI libraries to the project (In THINK 6, ANSI is inthe Standard Libraries
folder - add it in its own segment), then create a new source code window. Save the
window as ColorMondrian.c and Add it to the project as well.
Type in this source code, being sure to save periodically:
/* 1 */
#include
#include
#define kMBARResID 128
#define kErrorAlertID 128
#define kAboutALRTid 129
#define kSleep 0L
#define kAutoStorage NULL
#define kVisible true
#define kWindowTitle "\pColor Mondrian
#define kMoveToFront (WindowPtr)-1
#define kNoGoAway false
#define kNULLRefCon 60L
#define mApple 128
#define iAbout 1
#define mFile 129
#define iQuit 1
#define mDevice 131
#define kWindowMargin 5
#define kRandomUpperLimit 32768
#define kEmptyString "\p
#define kNULLFilterProc NULL
/*************/
/* Globals */
/*************/
Boolean gDone;
/***************/
/* Functions */
/***************/
void ToolboxInit( void );
void MenuBarInit( void );
void CreateWindow( GDHandle device );
void EventLoop( void );
void DoEvent( EventRecord * eventPtr );
void HandleMouseDown( EventRecord * eventPtr );
void HandleMenuChoice( long menuChoice );
void HandleAppleChoice( short item );
void HandleFileChoice( short item );
void HandleDeviceChoice( short item );
Boolean HasColorQD( void );
GDHandle GetDeepestDevice( void );
short GetDeviceDepth( GDHandle device );
void DrawRandomRect( void );
void RandomColor( RGBColor *colorPtr );
void RandomRect( Rect *rectPtr );
short Randomize( short range );
void DoError( Str255 errorString );
/****************** main ***************************/
void main( void )
{
ToolboxInit();
if ( ! HasColorQD() )
DoError(
"\pThis machine doesn't support Color Quickdraw!" );
MenuBarInit();
CreateWindow( GetDeepestDevice() );
EventLoop();
}
/****************** ToolboxInit *********************/
void ToolboxInit( void )
{
InitGraf( &thePort );
InitFonts();
InitWindows();
InitMenus();
TEInit();
InitDialogs( nil );
InitCursor();
}
/****************** MenuBarInit ***********************/
void MenuBarInit( void )
{
Handle menuBar;
MenuHandle menu;
GDHandle device, deepestDevice;
Str255 itemStr;
short curDeviceNumber = 1;
menuBar = GetNewMBar( kMBARResID );
SetMenuBar( menuBar );
menu = GetMHandle( mApple );
AddResMenu( menu, 'DRVR' );
menu = GetMHandle( mDevice );
deepestDevice = GetDeepestDevice();
device = GetDeviceList();
while ( device != NULL )
{
itemStr[0] = 10;
sprintf( (char *)(&(itemStr[1])), "0x%08lX",
(unsigned long)device );
AppendMenu( menu, itemStr );
if ( device == deepestDevice )
CheckItem( menu, curDeviceNumber, true );
device = GetNextDevice( device );
curDeviceNumber++;
}
DrawMenuBar();
}
/****************** CreateWindow ***********************/
void CreateWindow( GDHandle device )
{
WindowPtr window;
Rect wBounds;
wBounds = (**device).gdRect;
if ( device == GetMainDevice() )
wBounds.top += GetMBarHeight();
InsetRect( &wBounds, kWindowMargin, kWindowMargin );
window = NewCWindow( kAutoStorage, &wBounds, kWindowTitle,
kVisible, altDBoxProc, kMoveToFront,
kNoGoAway, kNULLRefCon );
if ( window == nil )
{
DoError( "\pCouldn't create window!" );
}
else
{
ShowWindow( window );
SetPort( window );
}
}
/******************************** EventLoop *********/
void EventLoop( void )
{
EventRecord event;
GetDateTime( (unsigned long *)(&randSeed) );
gDone = false;
while ( gDone == false )
{
if ( WaitNextEvent( everyEvent, & event, kSleep, nil ) )
DoEvent( &event );
DrawRandomRect();
}
}
/************************************* DoEvent *********/
void DoEvent( EventRecord * eventPtr )
{
char theChar;
switch ( eventPtr->what )
{
case mouseDown:
HandleMouseDown( eventPtr );
break;
case keyDown:
case autoKey:
theChar = eventPtr->message & charCodeMask;
if ( ( eventPtr->modifiers & cmdKey) != 0 )
HandleMenuChoice( MenuKey( theChar ) );
break;
}
}
/****************************** HandleMouseDown *********/
void HandleMouseDown( EventRecord * eventPtr )
{
WindowPtr window;
short thePart;
long menuChoice;
thePart = FindWindow( eventPtr->where, &window );
switch ( thePart )
{
case inMenuBar:
menuChoice = MenuSelect( eventPtr->where );
HandleMenuChoice( menuChoice );
break;
case inSysWindow :
SystemClick( eventPtr, window );
break;
}
}
/****************** HandleMenuChoice ***********************/
void HandleMenuChoice( long menuChoice )
{
short menu;
short item;
if ( menuChoice != 0 )
{
menu = HiWord( menuChoice );
item = LoWord( menuChoice );
switch ( menu )
{
case mApple:
HandleAppleChoice( item );
break;
case mFile:
HandleFileChoice( item );
break;
case mDevice:
HandleDeviceChoice( item );
break;
}
HiliteMenu( 0 );
}
}
/****************** HandleAppleChoice ***********************/
void HandleAppleChoice( short item )
{
MenuHandle appleMenu;
Str255 accName;
short accNumber;
switch ( item )
{
case iAbout:
NoteAlert( kAboutALRTid, kNULLFilterProc );
break;
default:
appleMenu = GetMHandle( mApple );
GetItem( appleMenu, item, accName );
accNumber = OpenDeskAcc( accName );
break;
}
}
/****************** HandleFileChoice ***********************/
void HandleFileChoice( short item )
{
switch ( item )
{
case iQuit :
gDone = true;
break;
}
}
/****************** HandleDeviceChoice **********************/
void HandleDeviceChoice( short item )
{
/* Try this:
Modify the program so that when a device is selected
from the Device menu, the current window gets closed and a
new window is opened on the selected device. Be careful when
you translate the menu item back into an address. Debug your
program thoroughly before you try to use the address as an
address. You don't want to accidentally reformat your hard
drive, right?
Also, don't forget to update the check mark!
*/
}
/****************** HasColorQD *****************/
Boolean HasColorQD( void )
{
unsigned char version[ 4 ];
OSErr err;
err = Gestalt( gestaltQuickdrawVersion, (long *)version );
if ( err != noErr )
{
SysBeep( 10 ); /* Error calling Gestalt!!! */
ExitToShell();
}
if ( version[ 2 ] > 0 )
return( true );
else
return( false );
}
/****************** GetDeepestDevice *****************/
GDHandle GetDeepestDevice( void )
{
GDHandle curDevice, maxDevice = NULL;
short curDepth, maxDepth = 0;
curDevice = GetDeviceList();
while ( curDevice != NULL )
{
curDepth = GetDeviceDepth( curDevice );
if ( curDepth > maxDepth )
{
maxDepth = curDepth;
maxDevice = curDevice;
}
curDevice = GetNextDevice( curDevice );
}
return( maxDevice );
}
/****************** GetDeviceDepth *****************/
short GetDeviceDepth( GDHandle device )
{
PixMapHandle screenPixMapH;
screenPixMapH = (**device).gdPMap;
return( (**screenPixMapH).pixelSize );
}
/****************** DrawRandomRect *****************/
void DrawRandomRect( void )
{
Rect randomRect;
RGBColor color;
RandomRect( &randomRect );
RandomColor( &color );
RGBForeColor( &color );
PaintOval( &randomRect );
}
/****************** RandomColor *********************/
void RandomColor( RGBColor *colorPtr )
{
colorPtr->red = Random() + 32767;
colorPtr->blue = Random() + 32767;
colorPtr->green = Random() + 32767;
}
/****************** RandomRect *********************/
void RandomRect( Rect *rectPtr )
{
WindowPtr window;
window = FrontWindow();
rectPtr->left = Randomize( window->portRect.right
- window->portRect.left );
rectPtr->right = Randomize( window->portRect.right
- window->portRect.left );
rectPtr->top = Randomize( window->portRect.bottom
- window->portRect.top );
rectPtr->bottom = Randomize( window->portRect.bottom
- window->portRect.top );
}
/****************** Randomize **********************/
short Randomize( short range )
{
long randomNumber;
randomNumber = Random();
if ( randomNumber < 0 )
randomNumber *= -1;
return( (randomNumber * range) / kRandomUpperLimit );
}
/***************** DoError ********************/
void DoError( Str255 errorString )
{
ParamText( errorString, kEmptyString,
kEmptyString, kEmptyString );
StopAlert( kErrorAlertID, kNULLFilterProc );
}
Running ColorMondrian
Save your changes, then select Run from the Project menu. If ColorQuickDraw
is not available on your machine (unlikely), an error message will appear.
Otherwise, a window, similar to the one shown in Figure 12, will appear on the
monitor with the deepest pixel settings.
Figure 12. ColorMondrian in action.
Bring the Finder to the front by selecting Finder from the applications menu at
the right end of the menu bar. Notice that ColorMondrian stops dead in its tracks. Go
back to ColorMondrian and select Quit from the File menu. Back in THINK C, select
Set Project Type... from the Project menu. Set the value in the SIZE Flags field to
5880 (you don’t have to fiddle with the popup menu - you can just type the number
in the field).
You’ve just set ColorMondrian up to continue processing events even when it is
running in the background. To prove this, select Run from the Project menu, then
bring the Finder to the front again. This time, ColorMondrian will continue running,
even in the background.
Next, click on the Devices menu. A hex address will appear for every monitor
attached to your Macintosh. A check-mark will appear next to the address
representing the monitor with the deepest settings. You’ll find out what the address
or addresses are for in next month’s column. Figure 13 shows my Devices menu. As
you can see, I’ve got two monitors attached to my Mac.
Figure 13. My devices menu.
If you’ve got more than one monitor on your machine, try using the Monitors
control panel to set one monitor to 1-bit and the other to a deeper setting. Run
ColorMondrian. The window should appear on the deeper monitor. Now switch the
settings so that the second monitor has the deeper settings. Run ColorMondrian again.
Now the window should appear on the other monitor.
Till Next Month...
Next, month we’ll get into all the theory behind ColorMondrian. Till then, take
a look through the code, then read up on Color QuickDraw in the pages of Inside
Macintosh or on your Mac, courtesy of THINK Reference.